#include "listoperation.h"

#include"qmath.h"

ListOperation::ListOperation()
{
}


/******************************************************************************
**功能:数组的最大值索引
**输入参数:double形数组
**输出参数:最大值索引
**作者:
**日期:
**参考:
*******************************************************************************/
int ListOperation::ListMax_Index(QList<double>l)
{
    if(l.length()==0) return 0;
    else
    {
        int IndexTemp=0;
        double ValTemp=l.at(0);
        for(int i=1;i<l.length();i++)
        {
            if(ValTemp<l.at(i))
            {
                ValTemp=l.at(i);
                IndexTemp=i;
            }
        }
        return IndexTemp;
    }

}
/******************************************************************************
**功能:数组的最大值
**输入参数:double形数组
**输出参数:最大值
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::ListMax_Val(QList<double>l)
{
    if(l.length()==0) return 0;
    else
    {
        double ValTemp=l.at(0);

        for(int i=1;i<l.length();i++)
        {
            if(ValTemp<l.at(i))
            {
                ValTemp=l.at(i);
            }
        }
        return ValTemp;
    }

}

int ListOperation::ListMax_Val_Int(QList<int>l)
{
    if(l.length()==0) return 0;
    else
    {
        int ValTemp=l.at(0);

        for(int i=1;i<l.length();i++)
        {
            if(ValTemp<l.at(i))
            {
                ValTemp=l.at(i);
            }
        }
        return ValTemp;
    }

}
/******************************************************************************
**功能:数组的最小值索引
**输入参数:double形数组
**输出参数:最小值索引
**作者:
**日期:
**参考:
*******************************************************************************/
int ListOperation::ListMin_Index(QList<double>l)
{
    int IndexTemp=0;
    if(l.length()==0) return 0;
    else
    {
        double ValTemp=l.at(0);
        for(int i=1;i<l.length();i++)
        {
            if(ValTemp>l.at(i))
            {
                ValTemp=l.at(i);
                IndexTemp=i;
            }
        }
        return IndexTemp;
    }
}
/******************************************************************************
**功能:数组的最小值
**输入参数:double形数组
**输出参数:最小值
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::ListMin_Val(QList<double>l)
{
    if(l.length()==0) return 0;
    else
    {
        double ValTemp=l.at(0);
        for(int i=1;i<l.length();i++)
        {
            if(ValTemp>l.at(i))
            {
                ValTemp=l.at(i);
            }
        }
        return ValTemp;
    }
}

int ListOperation::ListMin_Val_Int(QList<int>l)
{
    if(l.length()==0) return 0;
    else
    {
        int ValTemp=l.at(0);
        for(int i=1;i<l.length();i++)
        {
            if(ValTemp>l.at(i))
            {
                ValTemp=l.at(i);
            }
        }
        return ValTemp;
    }
}
/******************************************************************************
**功能:数组的平均值
**输入参数:int形数组
**输出参数:平均值
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::ListAverage(QList<int>l)
{
    double sum=0;
    for(int i=0;i<l.length();i++)
    {
        sum+=l.at(i);
    }
    if(l.length()==0) return 0;
    else  return sum/l.length();
}

/******************************************************************************
**功能:数组的平均值
**输入参数:double形数组
**输出参数:平均值
**作者:whb
**日期:2015/09/03
**参考:
*******************************************************************************/
double ListOperation::ListAverage(QList<double>l)
{
    double sum=0;
    for(int i=0;i<l.length();i++)
    {
        sum+=l.at(i);
    }
    if(l.length()==0) return 0;
    else return sum/l.length();
}
/******************************************************************************
**功能:int形数组子集
**输入参数:int形数组,开始索引，数组长度
**输出参数:int形数组子集
**作者:
**日期:
**参考:
*******************************************************************************/
QList<int> ListOperation::ListSub(QList<int>List,int startIndex,int ListLength)
{
    QList <int>l;
    for(int i=0;i<qMin(ListLength,List.length()-startIndex);i++)
    {
        l.insert(i,List.at(i+startIndex));
    }
        return l;
}
/******************************************************************************
**功能:double形数组子集
**输入参数:double形数组,开始索引，数组长度
**输出参数:double形数组子集
**作者:
**日期:
**参考:
*******************************************************************************/
QList<double> ListOperation::ListSub(QList<double>List,int startIndex,int ListLength)
{
    QList <double>l;
    for(int i=0;i<qMin(ListLength,List.length()-startIndex);i++)
    {
        l.insert(i,List.at(i+startIndex));
    }
        return l;
}
/******************************************************************************
**功能:升序排列数组
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
// QList<int> ListOperation::ListSortbySX(QList<int>list)
// {
//     for(int i = 0; i<list.length(); i++)
//     {
//         for (int j = i+1; j < list.length(); j++)
//         {

//             if(list.at(i) > list.at(j))
//             {
//                 list.swap(i,j);
//             }
//         }
//     }
//     return list;
// }
// /******************************************************************************
// **功能:降序排列数组
// **输入参数:
// **输出参数:
// **作者:
// **日期:
// **参考:
// *******************************************************************************/
// QList<int> ListOperation::ListSortbyJX(QList<int>list)
// {
//     for(int i = 0; i<list.length(); i++)
//     {
//         for (int j = i+1; j < list.length(); j++)
//         {

//             if(list.at(i) < list.at(j))
//             {
//                 list.swap(i,j);
//             }
//         }
//     }
//     return list;
// }
/******************************************************************************
**功能:差分序列
**输入参数:int序列
**输出参数:int差分序列
**作者:
**日期:
**参考:
*******************************************************************************/
QList<int>ListOperation::ListDiff(QList<int>list)
{
    QList<int> temp;
    if(list.length()<2)
    {
        return list;
    }else
    {
        for(int i=0;i<list.length()-1;i++)
        {
            temp.insert(i,list.at(i+1)-list.at(i));
        }
        return temp;
    }
}
QList<double>ListOperation::ListDiff(QList<double>list)
{
    QList<double> temp;
    if(list.length()<2)
    {
        return list;
    }else
    {
        for(int i=0;i<list.length()-1;i++)
        {
            temp.insert(i,list.at(i+1)-list.at(i));
        }
        return temp;
    }
}

/******************************************************************************
**功能:两个LIst的点积
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
int ListOperation::DotP(QList<double>l1,QList<double>l2)
{
    int D=0;
    int len1,len2,len;
    len1=l1.length();
    len2=l2.length();

    len=qMin(len1,len2);

        for(int i=0;i<len;i++)
        {
            D+=l1.at(i)*l2.at(i);
        }
        return D;
}

/******************************************************************************
**功能:数与数组的乘积
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/

QList<double> ListOperation::NumMulArray(double Num,QList<double>l)
{
    QList<double>res;
    for(int i=0;i<l.length();i++)
    {
        res.append(Num*l.at(i));
    }
    return res;
}


/******************************************************************************
**功能:数组与数组的乘积
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
QList<double> ListOperation::ArrMulArr(QList<double>l1,QList<double>l2)
{
    int len=qMin(l1.length(),l2.length());
    QList<double> res;
    for(int i=0;i<len;i++)
    {
        res.append(l1.at(i)*l2.at(i));
    }
    return res;
}

/******************************************************************************
**功能:翻转一维数组
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
QList<double> ListOperation:: ArrayReverse(QList<double> arr)
{
    QList<double>out;
    for(int i=0;i<arr.length();i++)
    {
        out.append(arr.at(arr.length()-i-1));
    }
    return out;
}


/******************************************************************************
**功能:求取int型一维数组的平均值
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::mean(QList<double>l) {
    double sum=0;
    for(int i=0;i<l.length();i++)
    {
        sum=sum+l[i];
    }
    return sum/l.length();
}

int ListOperation::mean_int(QList<int>l) {
    int sum=0;
    for(int i=0;i<l.length();i++)
    {
        sum=sum+l[i];
    }
    return (int)sum/l.length();
}


struct ArrayMinMaxValIndex{
    int MinIndex,MaxIndex;
    double MinVal,MaxVal;
};



/******************************************************************************
**功能:求取一维数组的最大值，最大值索引，最小值和最小值索引
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
ArrayMinMaxValIndex ListOperation::ListMinMaxValIndex(QList<double>l)
{
    int MaxPosition=0;
    int MinPosition=0;
    double Max=l.at(0);
    double Min=l.at(0);
    for(int i=1;i<l.length();i++)
    {
        if(Max<l.at(i))
        {
            Max=l.at(i);
            MaxPosition=i;
        }
        if(Min>l.at(i))
        {
            Min=l.at(i);
            MinPosition=i;
        }
    }
    ArrayMinMaxValIndex AM;
    AM.MaxVal=Max;
    AM.MaxIndex=MaxPosition;
    AM.MinVal=Min;
    AM.MinIndex=MinPosition;
    return AM;
}

/******************************************************************************
**功能:list数组的子数组
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
QList<double> ListOperation::SubList(QList<double>l,int index,int len)
{
    QList<double>temp;
    int len1=l.length()-index;
    if(len>len1){
        len=len1;
    }
    for(int i=index;i<index+len;i++)
    {
        temp.append(l.at(i));
    }
    return temp;
}
QList<double> ListOperation::DelList(QList<double>l,int len){
    int llen=l.length();
    if(len<llen){
        for(int i=0;i<llen-len;i++){
            l.removeFirst();
        }
    }
    return l;
}

QList<double> ListOperation::ListAndList(QList<double>l1,QList<double>l2)
{
    QList<double>res;
    int len=qMin(l1.length(),l2.length());
    for(int i=0;i<len;i++)
    {
        res.append(l1.at(i)+l2.at(i));
    }
    return res;
}
/******************************************************************************
**功能:数组求和
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::ListSum(QList<double>l)
{
    double sum;
    for(int i=0;i<l.length();i++)
    {
        sum+=l.at(i);
    }
    return sum;
}

/******************************************************************************
**功能:一维数组的平均值
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::ListMean(QList<int>l)
{
    double sum;
    if(l.length()==0) return 0;
    else
    {
        for(int i=0;i<l.length();i++)
        {
            sum+=l.at(i);
        }
        return sum/l.length();
    }
}
double ListOperation::ListMean(QList<double>l)
{
    double sum;
    if(l.length()==0) return 0;
    else
    {
        for(int i=0;i<l.length();i++)
        {
            sum+=l.at(i);
        }
        return sum/l.length();
    }
}
/******************************************************************************
**功能:
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::ListRMS(QList<int >l)
{
        double temp=0;
        if(l.length()==0) return 0;
        else
        {
            for(int i=0;i<l.length();i++)
            {
                temp=temp+qPow(l.at(i), 2);
            }
           return qSqrt(temp/l.length());
        }
}
QList<int> ListOperation::ListAddRR(QList<int>l1,QList<int>l2){
    QList<int>temp;
    if(l1.length()>0){
        int lastv=l1.at(l1.length()-1);
        for(int i=0;i<l2.length();i++){
            if(l2.at(i)>lastv){
                if((l2.at(i)-lastv)>300&&(l2.at(i)-lastv)<800){
                    temp.append(l2.at(i)-lastv);
                }
                lastv=l2.at(i);
            }
        }
    }else{
        temp.append(ListDiff(l2));
    }
    return temp;
}

QList<int> ListOperation::ListAddRpos(QList<int>l1,QList<int>l2){
    QList<int>temp;
    if(l1.length()>0){
        int lastv=l1.at(l1.length()-1);
        for(int i=0;i<l2.length();i++){
            if(l2.at(i)>lastv){
                    temp.append(l2.at(i));
            }
        }
    }else{
        temp.append(l2);
    }
    return temp;
}
/******************************************************************************
**功能:RR间期标准差
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
double ListOperation::ListSTD(QList<int>l)
{
    double temp=0;
    if(l.length()==0) return 0;
    else
    {
        for(int i=0;i<l.length();i++)
        {
            temp+=qPow(l.at(i)-ListMean(l),2);
        }
        return qSqrt(temp/l.length()-1) ;
    }
}
double ListOperation::ListSTD(QList<double>l)
{
    double temp=0;
    if(l.length()==0) return 0;
    else
    {
        for(int i=0;i<l.length();i++)
        {
            temp+=qPow(l.at(i)-ListMean(l),2);
        }
        return qSqrt(temp/l.length()-1) ;
    }
}
/******************************************************************************
**功能:
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
int ListOperation::NumofGreatthanFiftyArr(QList<int>l)
{
    int Num=0;
    for(int i=0;i<l.length();i++)
    {
        if(qAbs(l.at(i))>50)
        {
            Num++;
        }
    }
    return Num;
}

/******************************************************************************
**功能:
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
QList<int> ListOperation::ArrayofDiff(QList<int>l)
{
    QList<int> res;
    if(l.length()<2)
    {
        res.append(1);
        return res;
    }

    else
    {
        for (int i=0;i<l.length()-1;i++)
        {
            res.append(l.at(i+1)-l.at(i));
        }
    }
    return res;
}


/******************************************************************************
**功能:数字和数组相加
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/

QList<int> ListOperation::NumAddArray(int num,QList<int>l)
{
    QList<int> res;
    for(int i=0;i<l.length();i++)
    {
        res.append(num+l.at(i));
    }
    return res;
}

/******************************************************************************
**功能:删除重复数
**输入参数:
**输出参数:
**作者:
**日期:
**参考:
*******************************************************************************/
QList<int> ListOperation::DelRepeatNum(QList<int>l)
{
    QList<int>difflist;
    QList<int>ReapeatPos;
    difflist=ListDiff(l);
    for(int i=0;i<difflist.length();i++)
    {
        if(difflist.at(i)<=0) ReapeatPos.append(i+1);
    }
    for(int i=ReapeatPos.length()-1;i>-1;i--)
    {
        l.removeAt(ReapeatPos.at(i));
    }
    return l;
}
